!pip install opencv-contrib-python
Requirement already satisfied: opencv-contrib-python in c:\users\aleja\anaconda3\lib\site-packages (4.5.1.48) Requirement already satisfied: numpy>=1.17.3 in c:\users\aleja\anaconda3\lib\site-packages (from opencv-contrib-python) (1.19.2)
import cv2
import matplotlib.pyplot as plt
import numpy as np
import math
from skimage import io, color
#Construimos una funcion que nos facilita la lectura de las imagenes
def img_read(filename, mode = 'color'):
if(mode == 'color'):
return cv2.cvtColor(cv2.imread(filename),cv2.COLOR_BGR2RGB)
elif(mode=='grayscale' or mode=='greyscale' or mode == 'gray' or mode == 'grey'):
return cv2.imread(filename, cv2.IMREAD_GRAYSCALE)
elif(mode=='yuv' or mode=='YUV'):
return cv2.cvtColor(cv2.imread(filename),cv2.COLOR_BGR2YUV)
elif(mode=='hsv' or mode=='HSV'):
return cv2.cvtColor(cv2.imread(filename),cv2.COLOR_BGR2HSV)
elif(mode=='lab' or mode=='LAB'):
return cv2.cvtColor(cv2.imread(filename),cv2.COLOR_BGR2LAB)
else:
return None
img_rgb = img_read('images/training/images/35_training.tif')
#Modelo RGB
img_R = img_rgb[:,:,0]
img_G = img_rgb[:,:,1]
img_B = img_rgb[:,:,2]
fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))
fig.suptitle('Canales RGB', fontsize=15)
ax1.set_title('Canal R')
ax1.imshow(img_R, cmap='gray')
ax2.set_title('Canal G')
ax2.imshow(img_G, cmap='gray')
ax3.set_title('Canal B')
ax3.imshow(img_B, cmap='gray')
<matplotlib.image.AxesImage at 0x195aed4a610>
img_cmy = img_read('images/training/images/35_training.tif')
#Modelo CMY
img_C= 255 - img_cmy[:,:,0]
img_M = 255 - img_cmy[:,:,1]
img_Y = 255 - img_cmy[:,:,2]
fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))
fig.suptitle('Canales CMY', fontsize=15)
ax1.set_title('Canal C')
ax1.imshow(img_C, cmap='gray')
ax2.set_title('Canal M')
ax2.imshow(img_M, cmap='gray')
ax3.set_title('Canal Y')
ax3.imshow(img_Y, cmap='gray')
<matplotlib.image.AxesImage at 0x195aee611f0>
img_yiq = img_read('images/training/images/35_training.tif')
#Modelo YIQ
img_R = img_yiq[:,:,0]
img_G = img_yiq[:,:,1]
img_B = img_yiq[:,:,2]
img_Y = 0.299*img_R + 0.587*img_G + 0.114*img_B
img_I = 0.596*img_R - 0.274*img_G - 0.322*img_B
img_Q = 0.211*img_R - 0.523*img_G + 0.312*img_B
fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))
fig.suptitle('Canales YIQ', fontsize=15)
ax1.set_title('Canal Y')
ax1.imshow(img_Y, cmap='gray')
ax2.set_title('Canal I')
ax2.imshow(img_I, cmap='gray')
ax3.set_title('Canal Q')
ax3.imshow(img_Q, cmap='gray')
<matplotlib.image.AxesImage at 0x195aef613d0>
img_yuv = img_read('images/training/images/35_training.tif',mode="yuv")
#Modelo YUV
img_Y = img_yuv[:,:,0]
img_U = img_yuv[:,:,1]
img_V = img_yuv[:,:,2]
fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))
fig.suptitle('Canales YUV', fontsize=15)
ax1.set_title('Canal Y')
ax1.imshow(img_Y, cmap='gray')
ax2.set_title('Canal U')
ax2.imshow(img_U, cmap='gray')
ax3.set_title('Canal V')
ax3.imshow(img_V, cmap='gray')
<matplotlib.image.AxesImage at 0x195b0589040>
img_HSL = img_read('images/training/images/35_training.tif')
#Modelo HSL
img_rgb = img_HSL.astype(np.float32)/255
img_R = img_rgb[:,:,0]
img_G = img_rgb[:,:,1]
img_B = img_rgb[:,:,2]
tam = np.shape(img_rgb)
img_hsl =np.zeros((tam), dtype=np.float32)
for i in range(tam[0]):
for j in range(tam[1]):
max_val = np.max(img_rgb[i][j])
min_val = np.min(img_rgb[i][j])
s = max_val - min_val
l = s/2
img_hsl[i][j][1] = s
img_hsl[i][j][2] = l
if(max_val==min_val):
img_hsl[i][j][0] = 0
continue
red = img_rgb[i][j][0]
green = img_rgb[i][j][1]
blue = img_rgb[i][j][2]
if(max_val == red):
h = (green-blue)*60/(max_val-min_val)
elif(max_val == green):
h = (blue-red)*60/(max_val-min_val) + 120
else:
h = (red-green)*60/(max_val-min_val) + 240
if h >= 0:
img_hsl[i,j,0]=h
else:
img_hsl[i,j,0] = 360.0 - h
fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))
fig.suptitle('Canales HSL', fontsize=15)
ax1.set_title('Canal H')
ax1.imshow(img_hsl[:,:,0], cmap='gray')
ax2.set_title('Canal S')
ax2.imshow(img_hsl[:,:,1], cmap='gray')
ax3.set_title('Canal L')
ax3.imshow(img_hsl[:,:,2], cmap='gray')
<matplotlib.image.AxesImage at 0x195b126c5b0>
img_hsv = img_read('images/training/images/35_training.tif',mode="hsv")
#Modelo HSV
img_H = img_hsv[:,:,0]
img_S = img_hsv[:,:,1]
img_V = img_hsv[:,:,2]
fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))
fig.suptitle('Canales HSV', fontsize=15)
ax1.set_title('Canal H')
ax1.imshow(img_H, cmap='gray')
ax2.set_title('Canal S')
ax2.imshow(img_S, cmap='gray')
ax3.set_title('Canal V')
ax3.imshow(img_V, cmap='gray')
<matplotlib.image.AxesImage at 0x195b1ffb370>
img_lab = img_read('images/training/images/35_training.tif',mode="lab")
#Modelo LAB
img_L = img_lab[:,:,0]
img_A = img_lab[:,:,1]
img_B = img_lab[:,:,2]
fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))
fig.suptitle('Canales LAB', fontsize=15)
ax1.set_title('Canal L')
ax1.imshow(img_L, cmap='gray')
ax2.set_title('Canal A')
ax2.imshow(img_A, cmap='gray')
ax3.set_title('Canal B')
ax3.imshow(img_B, cmap='gray')
<matplotlib.image.AxesImage at 0x195b20ea550>
Procederemos a hacer una comparacion entre estos tres canales seleccionados con cinco distintas imagenes del dataset que creemos tienen unas caracteristicas distintivas, como una mayor iluminacion o un color de la retina un tanto distinto. Para asi hallar el canal mas apropiado para todo tipo de situación.
#Leamos estas imagenes representativas para compararlas
imagen1 = img_read('images/training/images/34_training.tif')
imagen2 = img_read('images/training/images/31_training.tif')
imagen3 = img_read('images/training/images/38_training.tif')
imagen4 = img_read('images/training/images/23_training.tif')
imagen5 = img_read('images/training/images/26_training.tif')
imagen1yuv = img_read('images/training/images/34_training.tif',mode="yuv")
imagen2yuv = img_read('images/training/images/31_training.tif',mode="yuv")
imagen3yuv = img_read('images/training/images/38_training.tif',mode="yuv")
imagen4yuv = img_read('images/training/images/23_training.tif',mode="yuv")
imagen5yuv = img_read('images/training/images/26_training.tif',mode="yuv")
fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(1,5, figsize=(15, 6))
fig.suptitle('Canal G - RGB', fontsize=15)
ax1.set_title('Canal G - Imagen 1')
ax1.imshow(imagen1[:,:,1], cmap='gray')
ax2.set_title('Canal G - Imagen 2')
ax2.imshow(imagen2[:,:,1], cmap='gray')
ax3.set_title('Canal G - Imagen 3')
ax3.imshow(imagen3[:,:,1], cmap='gray')
ax4.set_title('Canal G - Imagen 4')
ax4.imshow(imagen4[:,:,1], cmap='gray')
ax5.set_title('Canal G - Imagen 5')
ax5.imshow(imagen5[:,:,1], cmap='gray')
fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(1,5, figsize=(15, 6))
fig.suptitle('Canal Y - YUV', fontsize=15)
ax1.set_title('Canal Y - Imagen 1')
ax1.imshow(imagen1yuv[:,:,0], cmap='gray')
ax2.set_title('Canal Y - Imagen 2')
ax2.imshow(imagen2yuv[:,:,0], cmap='gray')
ax3.set_title('Canal Y - Imagen 3')
ax3.imshow(imagen3yuv[:,:,0], cmap='gray')
ax4.set_title('Canal Y - Imagen 4')
ax4.imshow(imagen4yuv[:,:,0], cmap='gray')
ax5.set_title('Canal Y - Imagen 5')
ax5.imshow(imagen5yuv[:,:,0], cmap='gray')
fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(1,5, figsize=(15, 6))
fig.suptitle('Canal M - CMY', fontsize=15)
ax1.set_title('Canal M - Imagen 1')
ax1.imshow(255 - imagen1[:,:,1], cmap='gray')
ax2.set_title('Canal M - Imagen 2')
ax2.imshow(255 - imagen2[:,:,1], cmap='gray')
ax3.set_title('Canal M - Imagen 3')
ax3.imshow(255 - imagen3[:,:,1], cmap='gray')
ax4.set_title('Canal M - Imagen 4')
ax4.imshow(255 - imagen4[:,:,1], cmap='gray')
ax5.set_title('Canal M - Imagen 5')
ax5.imshow(255 - imagen5[:,:,1], cmap='gray')
<matplotlib.image.AxesImage at 0x195b3bfdc40>
# Tranformaciones basicas de suma y resta
# img = img_read('images/training/images/34_training.tif')
# img_add = np.zeros(img.shape, np.uint8)
# q = 40 ; w = 40; e = 40;
# img_add[:,:,0] = cv2.add(img[:,:,0], q)
# img_add[:,:,1] = cv2.add(img[:,:,1], w)
# img_add[:,:,2] = cv2.add(img[:,:,2], e)
# fig, arreglo_plots = plt.subplots(2,2, figsize=(15, 15))
# colors = ('r','g','b')
# arreglo_plots[0,0].set_title('Imagen original')
# arreglo_plots[0,0].imshow(img, cmap="gray")
# arreglo_plots[0,1].set_title('Histograma original')
# for i,col in enumerate(colors):
# img_array_i = img[:,:,i].ravel()
# arreglo_plots[0,1].hist(img_array_i,histtype='step', bins=255,
# range=(0.0, 255.0),density=True, color=colors[i])
# arreglo_plots[1,0].set_title('Imagen modificada')
# arreglo_plots[1,0].imshow(img_add, cmap="gray")
# arreglo_plots[1,1].set_title('Histograma modificado')
# for i,col in enumerate(colors):
# img_array_i = img_add[:,:,i].ravel()
# arreglo_plots[1,1].hist(img_array_i,histtype='step', bins=255,
# range=(0.0, 255.0),density=True, color=colors[i])
# #Tranformaciones basicas de multiplicacion y division
# img = img_read('images/training/images/34_training.tif')
# img_mult = np.zeros(img.shape, np.uint8)
# q = 1.8; w = 1.8; e = 1.8;
# img_mult[:,:,0] = cv2.multiply(img[:,:,0], q)
# img_mult[:,:,1] = cv2.multiply(img[:,:,1], w)
# img_mult[:,:,2] = cv2.multiply(img[:,:,2], e)
# fig, arreglo_plots = plt.subplots(2,2, figsize=(15, 15))
# colors = ('r','g','b')
# arreglo_plots[0,0].set_title('Imagen original')
# arreglo_plots[0,0].imshow(img, cmap="gray")
# arreglo_plots[0,1].set_title('Histograma original')
# for i,col in enumerate(colors):
# img_array_i = img[:,:,i].ravel()
# arreglo_plots[0,1].hist(img_array_i,histtype='step', bins=255,
# range=(0.0, 255.0),density=True, color=colors[i])
# arreglo_plots[1,0].set_title('Imagen modificada')
# arreglo_plots[1,0].imshow(img_mult, cmap="gray")
# arreglo_plots[1,1].set_title('Histograma modificado')
# for i,col in enumerate(colors):
# img_array_i = img_mult[:,:,i].ravel()
# arreglo_plots[1,1].hist(img_array_i,histtype='step', bins=255,
# range=(0.0, 255.0),density=True, color=colors[i])
Se implemento la corrección o transformación Gamma, la cual se usa para manipular el contraste y realzar la imagen. Para este caso con el fin de aumentar el brillo, lo cual nos permitió resaltar la visualización de los vasos.
img_rgb = img_read('images/training/images/35_training.tif')
#Modelo RGB
img_R = img_rgb[:,:,0]
img_G = img_rgb[:,:,1]
img_B = img_rgb[:,:,2]
#Definimos esta función para detectar bordes, la usaremos mas adelante
def detect_edge(image, umbral_min, umbral_max, titulo = "Imagen original",canal = ""): #Angie : añadi un parametro mas que es para poner el nombre del canal
image_with_edges = cv2.Canny(image , umbral_min, umbral_max)
fig, (ax1, ax2) = plt.subplots(1,2, figsize=(15, 6))
fig.suptitle(canal, fontsize=15)
ax1.set_title(titulo)
ax1.imshow(image, cmap='gray')
ax2.set_title('Bordes')
ax2.imshow(image_with_edges, cmap='gray')
#Definir la función de transformación de la imagen (corrección gamma)
def gamma_correction(img, a, gamma):
#Crear copia de la imagen tipo flotante dada la normalización
img_copy = img.copy().astype(np.float32)/255.0
#La función corrección gamma es de la forma ax^gamma donde x es la imagen de entrada
res_gamma = cv2.pow(img_copy, gamma)
res = cv2.multiply(res_gamma, a)
#Asegurar que la los datos queden entre 0 y 255 y sean uint8
res[res<0] = 0
res = res*255.0
res[res>255] = 255
res = res.astype(np.uint8)
return res
#Leer la imagen de entrada
#Variar los parámetros a y gamma y volver a aplicar la corrección
a = 1.5
gamma = 0.8
res_oscuro = gamma_correction(img_G, a, gamma)
#Usamos nuestra función para observar la diferencia en detección de bordes de la imagen antes y despues de la corrección
detect_edge(img_G, 80, 140)
detect_edge(res_oscuro, 80, 140,"Imagen con corrección gamma")
#se varian los valores de a y gama.
a= 1.45
gamma = 0.9
#CANAL G - RGB
g_imagen1=gamma_correction(imagen1[:,:,1],a,gamma)
g_imagen2=gamma_correction(imagen2[:,:,1],a,gamma)
g_imagen3=gamma_correction(imagen3[:,:,1],a,gamma)
g_imagen4=gamma_correction(imagen4[:,:,1],a,gamma)
g_imagen5=gamma_correction(imagen5[:,:,1],a,gamma)
#CANAL Y - YUV
ay=1.8 #se varian los valores de a y gama.
gammay=0.9
g_imagen1yuv=gamma_correction(imagen1yuv[:,:,1],ay,gammay)
g_imagen2yuv=gamma_correction(imagen2yuv[:,:,1],ay,gammay)
g_imagen3yuv=gamma_correction(imagen3yuv[:,:,1],ay,gammay)
g_imagen4yuv=gamma_correction(imagen4yuv[:,:,1],ay,gammay)
g_imagen5yuv=gamma_correction(imagen5yuv[:,:,1],ay,gammay)
#CANAL M - CMY
am=1.2 #se varian los valores de a y gama.
gammam=1.2
g_imagen1cmy=gamma_correction(255-imagen1[:,:,1],0.9,gammam)
g_imagen2cmy=gamma_correction(255-imagen2[:,:,1],am,gammam)
g_imagen3cmy=gamma_correction(255-imagen3[:,:,1],am,gammam)
g_imagen4cmy=gamma_correction(255-imagen4[:,:,1],am,gammam)
g_imagen5cmy=gamma_correction(255-imagen5[:,:,1],am,gammam)
#DETECCION DE BORDES
#CANAL G - RGB
detect_edge(imagen1[:,:,1],80,140,"Imagen Original 1","Canal G - RGB")
detect_edge(g_imagen1,80,140,"Imagen con correccion gama")
#Imagen 2
detect_edge(imagen2[:,:,1],60,140,"Imagen Original 2")
detect_edge(g_imagen2,60,140,"Imagen con correccion gama")
#imagen 3
detect_edge(imagen3[:,:,1],60,140,"Imagen Original 3")
detect_edge(g_imagen3,60,140,"Imagen con correccion gama")
#imagen 4
detect_edge(imagen4[:,:,1],60,140,"Imagen Original 4")
detect_edge(g_imagen4,60,140,"Imagen con correccion gama")
#imagen 5
detect_edge(imagen5[:,:,1],60,140,"Imagen Original 5")
detect_edge(g_imagen5,60,140,"Imagen con correccion gama")
# #CANAL Y -YUV
# detect_edge(imagen1yuv[:,:,0],60,140,"Imagen Original 1","Canal Y - YUV")
# detect_edge(g_imagen1yuv,10,70,"Imagen con correccion gama")
# #Imagen 2
# detect_edge(imagen2yuv[:,:,0],60,140,"Imagen Original 2")
# detect_edge(g_imagen2yuv,10,70,"Imagen con correccion gama")
# #imagen 3
# detect_edge(imagen3yuv[:,:,0],60,140,"Imagen Original 3")
# detect_edge(g_imagen3yuv,10,70,"Imagen con correccion gama")
# #imagen 4
# detect_edge(imagen4yuv[:,:,0],60,140,"Imagen Original 4")
# detect_edge(g_imagen4yuv,10,70,"Imagen con correccion gama")
# #imagen 5
# detect_edge(imagen5yuv[:,:,0],60,140,"Imagen Original 5")
# detect_edge(g_imagen5yuv,10,70,"Imagen con correccion gama")
# #CANAL M - CMY
# detect_edge(255-imagen1[:,:,1],60,140,"Imagen Original 1","Canal M - CMY")
# detect_edge(g_imagen1cmy,60,140,"Imagen con correccion gama")
# #imagen 2
# detect_edge(255-imagen2[:,:,1],60,140,"Imagen Original 2")
# detect_edge(g_imagen2cmy,60,140,"Imagen con correccion gama")
# #imagen 3
# detect_edge(255-imagen3[:,:,1],60,140,"Imagen Original 3")
# detect_edge(g_imagen3cmy,60,140,"Imagen con correccion gama")
# #imagen 4
# detect_edge(255-imagen4[:,:,1],60,140,"Imagen Original 4")
# detect_edge(g_imagen4cmy,60,140,"Imagen con correccion gama")
# #imagen 5
# detect_edge(255-imagen5[:,:,1],60,140,"Imagen Original 5")
# detect_edge(g_imagen5cmy,60,140,"Imagen con correccion gama")
#Definir la función ecualización del histograma cuyo parámetro es una imagen
img_rgb1 = img_read('images/training/images/29_training.tif')
#Modelo RGB
img_G2 = img_rgb1[:,:,1]
def histogram_equalization(img):
#Crear matriz de ceros del tamaño de la imagen y tipo de dato flotante
res = np.zeros(img.shape, np.float32)
#Crear un vector 1-D de la matriz de la imagen es decir \aplanarla\
img_raveled = img.ravel()
#Generar el histograma normalizado de la imagen
hist_norm = plt.hist(img_raveled, bins=255, range=(0.0, 255.0), density=True)
#Limpiar la figura actual
plt.clf()
#hist_norm[0] es un vector de probabilidades. Añadir al vector el valor [1 - sumatoria de sus datos]
pdf = hist_norm[0]
np.append(pdf, 1.0 - np.sum(pdf))
#Dado que se añade un dato se realiza la sumatoria de valores sobre todo el vector
cdf = [np.sum(pdf[0:x]) for x in range(0,256)]
#Hallar el valor mínimo y máximo de la imagen
gmin = np.min(img)
gmax = np.max(img)
#Generar F(g) - Función de ecualización
for g in range(0,256):
res[img == g] = (gmax - gmin)*cdf[g] + gmin
#Asegurar que los datos sean uint8 y esten en el rango correspondiente
res[res<0] = 0
res[res>255] = 255
res = res.astype(np.uint8)
return res
#Leer la imagen y aplicar la transformación ecualización del histograma sobre ésta
res_ecua= histogram_equalization(img_G2)
#Generar subplot 2x3 para mostrar imagen histograma y función de densidad acumulada
fig, arreglo_plots = plt.subplots(2,2 ,figsize=(10 ,10))
colors = ('r','g','b')
arreglo_plots[0,0].set_title('Imagen original')
arreglo_plots[0,0].imshow(img_G2, cmap='gray')
arreglo_plots[0,1].set_title('Histograma original')
img_array_i = img_G.ravel()
_=arreglo_plots[0,1].hist(img_array_i,histtype='step', bins=255 ,
range=(0.0, 255.0),density=True ,color=colors[1])
arreglo_plots[1,0].set_title('Imagen modificada')
arreglo_plots[1,0].imshow(res_ecua, cmap="gray")
arreglo_plots[1,1].set_title('Histograma modificado')
img_array_i = res_ecua.ravel()
_=arreglo_plots[1,1].hist(img_array_i,histtype='step', bins=255,
range=(0.0, 255.0),density=True, color=colors[1])
<Figure size 432x288 with 0 Axes>
#funcion para mostrar la ecualizacion de las imagenes
def mostrar_eh(img1,img2,imagen="",canal=""):
fig, arreglo_plots = plt.subplots(1,4 ,figsize=(20 ,3))
fig.suptitle(canal,fontsize=16)
colors = ('r','g','b')
arreglo_plots[0].set_title(imagen)
arreglo_plots[0].imshow(img1, cmap='gray')
arreglo_plots[1].set_title('Histograma original')
img_array_i = img1.ravel()
_=arreglo_plots[1].hist(img_array_i,histtype='step', bins=255 ,
range=(0.0, 255.0),density=True ,color=colors[1])
arreglo_plots[2].set_title("Imagen Modificada")
arreglo_plots[2].imshow(img2, cmap="gray")
arreglo_plots[3].set_title('Histograma modificado')
img_array_i = img2.ravel()
_=arreglo_plots[3].hist(img_array_i,histtype='step', bins=255,
range=(0.0, 255.0),density=True, color=colors[1])
#aplicacion de ecualizacion
#CANAL G - RGB
e_imagen1=histogram_equalization(imagen1[:,:,1])
e_imagen2=histogram_equalization(imagen2[:,:,1])
e_imagen3=histogram_equalization(imagen3[:,:,1])
e_imagen4=histogram_equalization(imagen4[:,:,1])
e_imagen5=histogram_equalization(imagen5[:,:,1])
#CANAL Y -YUV
e_imagen1yuv=histogram_equalization(imagen1yuv[:,:,1])
e_imagen2yuv=histogram_equalization(imagen2yuv[:,:,1])
e_imagen3yuv=histogram_equalization(imagen3yuv[:,:,1])
e_imagen4yuv=histogram_equalization(imagen4yuv[:,:,1])
e_imagen5yuv=histogram_equalization(imagen5yuv[:,:,1])
#CANAL M - CMY
e_imagen1cmy=histogram_equalization(255-imagen1[:,:,1])
e_imagen2cmy=histogram_equalization(255-imagen2[:,:,1])
e_imagen3cmy=histogram_equalization(255-imagen3[:,:,1])
e_imagen4cmy=histogram_equalization(255-imagen4[:,:,1])
e_imagen5cmy=histogram_equalization(255-imagen5[:,:,1])
mostrar_eh(imagen1[:,:,1],e_imagen1,"Imagen original 1","Canal G - RGB"+"\n")
mostrar_eh(imagen2[:,:,1],e_imagen2,"Imagen original 2")
mostrar_eh(imagen3[:,:,1],e_imagen3,"Imagen original 3")
mostrar_eh(imagen4[:,:,1],e_imagen4,"Imagen original 4")
mostrar_eh(imagen5[:,:,1],e_imagen5,"Imagen original 5")
# mostrar_eh(imagen1yuv[:,:,0],e_imagen1yuv,"Imagen original 1","Canal Y - YUV")
# mostrar_eh(imagen2yuv[:,:,0],e_imagen2yuv,"Imagen original 2")
# mostrar_eh(imagen3yuv[:,:,0],e_imagen3yuv,"Imagen original 3")
# mostrar_eh(imagen4yuv[:,:,0],e_imagen4yuv,"Imagen original 4")
# mostrar_eh(imagen5yuv[:,:,0],e_imagen5yuv,"Imagen original 5")
# mostrar_eh(255-imagen1[:,:,1],e_imagen1cmy,"Imagen original 1","Canal M - CMY")
# mostrar_eh(255-imagen2[:,:,1],e_imagen2cmy,"Imagen original 2")
# mostrar_eh(255-imagen3[:,:,1],e_imagen3cmy,"Imagen original 3")
# mostrar_eh(255-imagen4[:,:,1],e_imagen4cmy,"Imagen original 4")
# mostrar_eh(255-imagen5[:,:,1],e_imagen5cmy,"Imagen original 5")
<Figure size 432x288 with 0 Axes>
res_gauss= cv2.GaussianBlur(res_ecua,(5, 5),2)
detect_edge(res_gauss, 60, 140, "Filtro gaussiano")
res_gauss2=cv2.GaussianBlur(e_imagen5,(5,5),2)
detect_edge(res_gauss2, 60, 140, "Filtro gaussiano")
#definicion de funcion para la aplicacion del filtro de media.
def filtro_mediab(imag,k_size):
#Aplica suavizado mediante la funcion blur
res1 = cv2.blur(imag,(k_size,k_size),borderType=cv2.BORDER_REPLICATE )
return res1
def filtro_media2d(imag,k_size):
#Aplica suavizado mediante filter2D
kernel = np.ones((k_size,k_size),np.float64)/(k_size**2)
res2 = cv2.filter2D(imag, ddepth=-1, kernel= kernel, borderType=cv2.BORDER_REPLICATE)
return res2
k_size=6 #valor tamaño del kernel
#CANAL G - RGB
fmb_imagen1,fmd_imagen1 = filtro_mediab(e_imagen1,k_size),filtro_media2d(e_imagen1,k_size)
fmb_imagen2,fmd_imagen2 = filtro_mediab(e_imagen2,k_size),filtro_media2d(e_imagen2,k_size)
fmb_imagen3,fmd_imagen3 = filtro_mediab(e_imagen3,k_size),filtro_media2d(e_imagen3,k_size)
fmb_imagen4,fmd_imagen4 = filtro_mediab(e_imagen4,k_size),filtro_media2d(e_imagen4,k_size)
#solo se mostro el filtro en la imagen 5
fmb_imagen5,fmd_imagen5 = filtro_mediab(e_imagen5,k_size),filtro_media2d(e_imagen5,k_size)
detect_edge(e_imagen5, 50, 120, "Imagen Ecualizada", "Imagen 5, Canal G - RGB")
detect_edge(fmb_imagen5, 50, 120, "Funcion Blur")
detect_edge(fmd_imagen5, 50, 120, "Funcion Filter2D")
# #IMAGEN 5 CANAL Y -YUV
# fmb_imagen1y,fmd_imagen1y = filtro_mediab(e_imagen1yuv,k_size),filtro_media2d(e_imagen1yuv,k_size)
# fmb_imagen2y,fmd_imagen2y = filtro_mediab(e_imagen2yuv,k_size),filtro_media2d(e_imagen2yuv,k_size)
# fmb_imagen3y,fmd_imagen3y = filtro_mediab(e_imagen3yuv,k_size),filtro_media2d(e_imagen3yuv,k_size)
# fmb_imagen4y,fmd_imagen4y = filtro_mediab(e_imagen4yuv,k_size),filtro_media2d(e_imagen4yuv,k_size)
# #solo se mostro el filtro en la imagen 5
# fmb_imagen5y,fmd_imagen5y = filtro_mediab(e_imagen5yuv,k_size),filtro_media2d(e_imagen5yuv,k_size)
# detect_edge(e_imagen5yuv, 20, 50, "Imagen Ecualizada", "Imagen 5, Canal Y - YUV")
# detect_edge(fmb_imagen5y, 20, 50, "Funcion Blur")
# detect_edge(fmd_imagen5y, 20, 50, "Funcion Filter2D")
# #IMAGEN 5 CANAL M - CMY
# fmb_imagen1m,fmd_imagen1m = filtro_mediab(e_imagen1cmy,k_size),filtro_media2d(e_imagen1cmy,k_size)
# fmb_imagen2m,fmd_imagen2m = filtro_mediab(e_imagen2cmy,k_size),filtro_media2d(e_imagen2cmy,k_size)
# fmb_imagen3m,fmd_imagen3m = filtro_mediab(e_imagen3cmy,k_size),filtro_media2d(e_imagen3cmy,k_size)
# fmb_imagen4m,fmd_imagen4m = filtro_mediab(e_imagen4cmy,k_size),filtro_media2d(e_imagen4cmy,k_size)
# fmb_imagen5m,fmd_imagen5m = filtro_mediab(e_imagen5cmy,k_size),filtro_media2d(e_imagen5cmy,k_size)
# #solo se mostro el filtro en la imagen 5
# detect_edge(e_imagen5cmy, 30, 120, "Imagen Ecualizada", "Imagen 5, Canal M - CMY")
# detect_edge(fmb_imagen5m, 30, 120, "Funcion Blur")
# detect_edge(fmd_imagen5m, 30, 120, "Funcion Filter2D")
#Definir tamaño del kernel
k_size = 9
#Aplicar filtro de mediana a la imagen de entrada
res1_g= cv2.medianBlur(e_imagen1, k_size)
res2_g= cv2.medianBlur(e_imagen2, k_size)
res3_g= cv2.medianBlur(e_imagen3, k_size)
res4_g= cv2.medianBlur(e_imagen4, k_size)
res5_g= cv2.medianBlur(e_imagen5, k_size)
res1_y= cv2.medianBlur(e_imagen1yuv, k_size)
res2_y= cv2.medianBlur(e_imagen2yuv, k_size)
res3_y= cv2.medianBlur(e_imagen3yuv, k_size)
res4_y= cv2.medianBlur(e_imagen4yuv, k_size)
res5_y= cv2.medianBlur(e_imagen5yuv, k_size)
res1_m= cv2.medianBlur(e_imagen1cmy, k_size)
res2_m= cv2.medianBlur(e_imagen2cmy, k_size)
res3_m= cv2.medianBlur(e_imagen3cmy, k_size)
res4_m= cv2.medianBlur(e_imagen4cmy, k_size)
res5_m= cv2.medianBlur(e_imagen5cmy, k_size)
#Solo se mostro la imagen 5 de cada canal escogido.
detect_edge(e_imagen5,50,130,"Imagen Original 5 Ecualizada","Canal G-RGB")
detect_edge(res5_g,50,130,"Imagen con filtro")
# detect_edge(e_imagen5yuv,10,55,"Imagen Original 5 Ecualizada","Canal Y - YUV")
# detect_edge(res5_y,10,55,"Imagen con filtro")
# detect_edge(e_imagen5cmy,30,140,"Imagen Original 5 Ecualizada","Canal M - CMY")
# detect_edge(res5_m,30,140,"Imagen con filtro")
#Definir función filtro del mínimo
def minimum_filter(img,k_size):
#Crear matriz de ceros del tamaño de imagen de entrada
res = np.zeros(img.shape, np.uint8)
#Definir el radio del kernel
r = math.floor(k_size/2)
#Recorrer cada posición i,j de la imagen con el kernel
for i in range(r, img.shape[0]-r):
for j in range(r, img.shape[1]-r):
#Tamaño de la ventana
window = img[i-r:i+r+1,j-r:j+r+1]
#Cambiar el valor de la posición i,j de la imagen por el de la ventana
min_val = np.min(window)
res[i,j] = min_val
return res
fig, (ax1) = plt.subplots(1, figsize=(15, 6))
ax1.imshow(minimum_filter(e_imagen5, 6), cmap ='gray')
detect_edge(minimum_filter(e_imagen5, k_size), 10, 120, "Filtro minimo")
#Definir función de Filtro del Máximo
def maximum_filter(img,k_size):
#Crear una matriz de ceros del tamaño de la imagen de entrada
res = np.zeros(img.shape, np.uint8)
#Radio del kernel
r = math.floor(k_size/2)
#Recorrer cada posición i,j de la imagen con el kernel
for i in range(r, img.shape[0]-r):
for j in range(r, img.shape[1]-r):
#Tamaño de la ventana
window = img[i-r:i+r+1,j-r:j+r+1]
#Cambiar el valor de la posición i,j de la imagen por el de la ventana
max_val = np.max(window)
res[i,j] = max_val
return res
fig, (ax1) = plt.subplots(1, figsize=(15, 6))
ax1.imshow(maximum_filter(e_imagen5, k_size), cmap ='gray')
detect_edge(maximum_filter(e_imagen5, k_size), 10, 120, "Filtro maximo")